const { comments, Comment } = require('../models/Comment');
const { generateId } = require('../utils');
const { validateNumber, validateRequiredFields } = require('../utils');
const { dbConfig } = require('../config/database');

// 获取所有评论
const getAllComments = async (req, res) => {
  try {
    // 检查是否使用数据库
    if (!dbConfig.useInMemory) {
      // 使用数据库模式
      try {
        const dbComments = await Comment.find({}).populate('postId');
        res.status(200).json(dbComments);
      } catch (dbError) {
        console.error('数据库查询失败:', dbError);
        // 降级到内存数据
        res.status(200).json(comments);
      }
    } else {
      // 使用内存数据模式
      res.status(200).json(comments);
    }
  } catch (error) {
    res.status(500).json({ 
      error: '获取评论列表失败',
      message: error.message 
    });
  }
};

// 根据文章ID获取评论
const getCommentsByPostId = (req, res) => {
  try {
    const { postId } = req.params;
    
    if (!validateNumber(postId)) {
      return res.status(400).json({ 
        error: '参数错误', 
        message: '文章ID必须是数字' 
      });
    }
    
    const commentsByPost = comments.filter(c => c.postId === parseInt(postId));
    
    res.status(200).json(commentsByPost);
  } catch (error) {
    res.status(500).json({ 
      error: '获取评论列表失败',
      message: error.message 
    });
  }
};

// 根据ID获取评论
const getCommentById = async (req, res) => {
  try {
    const { id } = req.params;
    
    if (!validateNumber(id)) {
      return res.status(400).json({ 
        error: '参数错误', 
        message: '评论ID必须是数字' 
      });
    }
    
    const commentId = parseInt(id);
    
    // 检查是否使用数据库
    if (!dbConfig.useInMemory) {
      // 使用数据库模式
      try {
        const comment = await Comment.findById(commentId).populate('postId');
        if (!comment) {
          return res.status(404).json({ 
            error: '评论未找到',
            message: `ID为${commentId}的评论不存在`
          });
        }
        res.status(200).json(comment);
      } catch (dbError) {
        console.error('数据库查询失败:', dbError);
        // 降级到内存数据
        const comment = comments.find(c => c.id === commentId);
        if (!comment) {
          return res.status(404).json({ 
            error: '评论未找到',
            message: `ID为${commentId}的评论不存在`
          });
        }
        res.status(200).json(comment);
      }
    } else {
      // 使用内存数据模式
      const comment = comments.find(c => c.id === commentId);
      if (!comment) {
        return res.status(404).json({ 
          error: '评论未找到',
          message: `ID为${commentId}的评论不存在`
        });
      }
      res.status(200).json(comment);
    }
  } catch (error) {
    res.status(500).json({ 
      error: '获取评论信息失败',
      message: error.message 
    });
  }
};

// 创建新评论
const createComment = async (req, res) => {
  try {
    const { content, author, postId } = req.body;
    
    // 验证必填字段
    const validation = validateRequiredFields({ content, author, postId }, ['content', 'author', 'postId']);
    if (!validation.isValid) {
      return res.status(400).json({ 
        error: '字段验证失败', 
        message: validation.errors.join(', ') 
      });
    }
    
    if (!validateNumber(postId)) {
      return res.status(400).json({ 
        error: '参数错误', 
        message: '文章ID必须是数字' 
      });
    }
    
    const postIdNum = parseInt(postId);
    
    // 检查是否使用数据库
    if (!dbConfig.useInMemory) {
      // 使用数据库模式
      try {
        const newComment = new Comment({ 
          content, 
          author, 
          postId: postIdNum,
          createdAt: new Date()
        });
        
        const savedComment = await newComment.save();
        res.status(201).json(savedComment);
      } catch (dbError) {
        console.error('数据库操作失败:', dbError);
        // 降级到内存数据
        const newComment = new Comment(
          generateId(comments),
          content,
          author,
          postIdNum
        );
        comments.push(newComment);
        res.status(201).json(newComment);
      }
    } else {
      // 使用内存数据模式
      const newComment = new Comment(
        generateId(comments),
        content,
        author,
        postIdNum
      );
      comments.push(newComment);
      res.status(201).json(newComment);
    }
  } catch (error) {
    res.status(500).json({ 
      error: '创建评论失败',
      message: error.message 
    });
  }
};

// 更新评论
const updateComment = async (req, res) => {
  try {
    const { id } = req.params;
    const { content, author, postId } = req.body;
    
    if (!validateNumber(id)) {
      return res.status(400).json({ 
        error: '参数错误', 
        message: '评论ID必须是数字' 
      });
    }
    
    const commentId = parseInt(id);
    
    // 验证必填字段
    const validation = validateRequiredFields({ content, author, postId }, ['content', 'author', 'postId']);
    if (!validation.isValid) {
      return res.status(400).json({ 
        error: '字段验证失败', 
        message: validation.errors.join(', ') 
      });
    }
    
    if (!validateNumber(postId)) {
      return res.status(400).json({ 
        error: '参数错误', 
        message: '文章ID必须是数字' 
      });
    }
    
    const postIdNum = parseInt(postId);
    
    // 检查是否使用数据库
    if (!dbConfig.useInMemory) {
      // 使用数据库模式
      try {
        const comment = await Comment.findByIdAndUpdate(
          commentId,
          { 
            content, 
            author, 
            postId: postIdNum
          },
          { new: true, runValidators: true }
        ).populate('postId');
        
        if (!comment) {
          return res.status(404).json({ 
            error: '评论未找到',
            message: `ID为${commentId}的评论不存在`
          });
        }
        
        res.status(200).json(comment);
      } catch (dbError) {
        console.error('数据库操作失败:', dbError);
        // 降级到内存数据
        const commentIndex = comments.findIndex(c => c.id === commentId);
        if (commentIndex === -1) {
          return res.status(404).json({ 
            error: '评论未找到',
            message: `ID为${commentId}的评论不存在`
          });
        }
        
        comments[commentIndex].content = content;
        comments[commentIndex].author = author;
        comments[commentIndex].postId = postIdNum;
        res.status(200).json(comments[commentIndex]);
      }
    } else {
      // 使用内存数据模式
      const commentIndex = comments.findIndex(c => c.id === commentId);
      if (commentIndex === -1) {
        return res.status(404).json({ 
          error: '评论未找到',
          message: `ID为${commentId}的评论不存在`
        });
      }
      
      comments[commentIndex].content = content;
      comments[commentIndex].author = author;
      comments[commentIndex].postId = postIdNum;
      res.status(200).json(comments[commentIndex]);
    }
  } catch (error) {
    res.status(500).json({ 
      error: '更新评论失败',
      message: error.message 
    });
  }
};

// 删除评论
const deleteComment = async (req, res) => {
  try {
    const { id } = req.params;
    
    if (!validateNumber(id)) {
      return res.status(400).json({ 
        error: '参数错误', 
        message: '评论ID必须是数字' 
      });
    }
    
    const commentId = parseInt(id);
    
    // 检查是否使用数据库
    if (!dbConfig.useInMemory) {
      // 使用数据库模式
      try {
        const comment = await Comment.findByIdAndDelete(commentId);
        if (!comment) {
          return res.status(404).json({ 
            error: '评论未找到',
            message: `ID为${commentId}的评论不存在`
          });
        }
        
        res.status(200).json({ message: '评论删除成功' });
      } catch (dbError) {
        console.error('数据库操作失败:', dbError);
        // 降级到内存数据
        const commentIndex = comments.findIndex(c => c.id === commentId);
        if (commentIndex === -1) {
          return res.status(404).json({ 
            error: '评论未找到',
            message: `ID为${commentId}的评论不存在`
          });
        }
        
        comments.splice(commentIndex, 1);
        res.status(200).json({ message: '评论删除成功' });
      }
    } else {
      // 使用内存数据模式
      const commentIndex = comments.findIndex(c => c.id === commentId);
      if (commentIndex === -1) {
        return res.status(404).json({ 
          error: '评论未找到',
          message: `ID为${commentId}的评论不存在`
        });
      }
      
      comments.splice(commentIndex, 1);
      res.status(200).json({ message: '评论删除成功' });
    }
  } catch (error) {
    res.status(500).json({ 
      error: '删除评论失败',
      message: error.message 
    });
  }
};

module.exports = {
  getAllComments,
  getCommentsByPostId,
  getCommentById,
  createComment,
  updateComment,
  deleteComment
};